/*
 * Register all the formats and protocols
 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */
#include "avformat.h"
#include "rtp.h"
#include "rdt.h"

#define REGISTER_MUXER(X,x) { \
    extern AVOutputFormat x##_muxer; \
    if(CONFIG_##X##_MUXER) av_register_output_format(&x##_muxer); }

#define REGISTER_DEMUXER(X,x) { \
    extern AVInputFormat x##_demuxer; \
    if(CONFIG_##X##_DEMUXER) av_register_input_format(&x##_demuxer); }

#define REGISTER_MUXDEMUX(X,x)  REGISTER_MUXER(X,x); REGISTER_DEMUXER(X,x)

#define REGISTER_PROTOCOL(X,x) { \
    extern URLProtocol x##_protocol; \
    if(CONFIG_##X##_PROTOCOL) av_register_protocol(&x##_protocol); }

void av_register_all(void)
{
    static int initialized;

    if (initialized)
        return;
    initialized = 1;

    avcodec_register_all();

#ifndef _MSC_VER

	/* (de)muxers */
	REGISTER_DEMUXER  (AAC, aac);
	REGISTER_MUXDEMUX (AC3, ac3);
	REGISTER_MUXER    (ADTS, adts);
	REGISTER_DEMUXER  (AEA, aea);
	REGISTER_MUXDEMUX (AIFF, aiff);
	REGISTER_MUXDEMUX (AMR, amr);
	REGISTER_DEMUXER  (ANM, anm);
	REGISTER_DEMUXER  (APC, apc);
	REGISTER_DEMUXER  (APE, ape);
	REGISTER_MUXDEMUX (ASF, asf);
	REGISTER_MUXDEMUX (ASS, ass);
	REGISTER_MUXER    (ASF_STREAM, asf_stream);
	REGISTER_MUXDEMUX (AU, au);
	REGISTER_MUXDEMUX (AVI, avi);
	REGISTER_DEMUXER  (AVISYNTH, avisynth);
	REGISTER_MUXER    (AVM2, avm2);
	REGISTER_DEMUXER  (AVS, avs);
	REGISTER_DEMUXER  (BETHSOFTVID, bethsoftvid);
	REGISTER_DEMUXER  (BFI, bfi);
	REGISTER_DEMUXER  (BINK, bink);
	REGISTER_DEMUXER  (C93, c93);
	REGISTER_DEMUXER  (CAF, caf);
	REGISTER_DEMUXER  (CAVSVIDEO, cavsvideo);
	REGISTER_DEMUXER  (CDG, cdg);
	REGISTER_MUXER    (CRC, crc);
	REGISTER_MUXDEMUX (DAUD, daud);
	REGISTER_MUXDEMUX (DIRAC, dirac);
	REGISTER_MUXDEMUX (DNXHD, dnxhd);
	REGISTER_DEMUXER  (DSICIN, dsicin);
	REGISTER_MUXDEMUX (DTS, dts);
	REGISTER_MUXDEMUX (DV, dv);
	REGISTER_DEMUXER  (DXA, dxa);
	REGISTER_DEMUXER  (EA, ea);
	REGISTER_DEMUXER  (EA_CDATA, ea_cdata);
	REGISTER_MUXDEMUX (EAC3, eac3);
	REGISTER_MUXDEMUX (FFM, ffm);
	REGISTER_MUXDEMUX (FILMSTRIP, filmstrip);
	REGISTER_MUXDEMUX (FLAC, flac);
	REGISTER_DEMUXER  (FLIC, flic);
	REGISTER_MUXDEMUX (FLV, flv);
	REGISTER_DEMUXER  (FOURXM, fourxm);
	REGISTER_MUXER    (FRAMECRC, framecrc);
	REGISTER_MUXER    (GIF, gif);
	REGISTER_DEMUXER  (GSM, gsm);
	REGISTER_MUXDEMUX (GXF, gxf);
	REGISTER_MUXDEMUX (H261, h261);
	REGISTER_MUXDEMUX (H263, h263);
	REGISTER_MUXDEMUX (H264, h264);
	REGISTER_DEMUXER  (IDCIN, idcin);
	REGISTER_DEMUXER  (IFF, iff);
	REGISTER_MUXDEMUX (IMAGE2, image2);
	REGISTER_MUXDEMUX (IMAGE2PIPE, image2pipe);
	REGISTER_DEMUXER  (INGENIENT, ingenient);
	REGISTER_DEMUXER  (IPMOVIE, ipmovie);
	REGISTER_MUXER    (IPOD, ipod);
	REGISTER_DEMUXER  (ISS, iss);
	REGISTER_DEMUXER  (IV8, iv8);
	REGISTER_DEMUXER  (LMLM4, lmlm4);
	REGISTER_MUXDEMUX (M4V, m4v);
	REGISTER_MUXDEMUX (MATROSKA, matroska);
	REGISTER_MUXER    (MATROSKA_AUDIO, matroska_audio);
	REGISTER_MUXDEMUX (MJPEG, mjpeg);
	REGISTER_MUXDEMUX (MLP, mlp);
	REGISTER_DEMUXER  (MM, mm);
	REGISTER_MUXDEMUX (MMF, mmf);
	REGISTER_MUXDEMUX (MOV, mov);
	REGISTER_MUXER    (MP2, mp2);
	REGISTER_MUXDEMUX (MP3, mp3);
	REGISTER_MUXER    (MP4, mp4);
	REGISTER_DEMUXER  (MPC, mpc);
	REGISTER_DEMUXER  (MPC8, mpc8);
	REGISTER_MUXER    (MPEG1SYSTEM, mpeg1system);
	REGISTER_MUXER    (MPEG1VCD, mpeg1vcd);
	REGISTER_MUXER    (MPEG1VIDEO, mpeg1video);
	REGISTER_MUXER    (MPEG2DVD, mpeg2dvd);
	REGISTER_MUXER    (MPEG2SVCD, mpeg2svcd);
	REGISTER_MUXER    (MPEG2VIDEO, mpeg2video);
	REGISTER_MUXER    (MPEG2VOB, mpeg2vob);
	REGISTER_DEMUXER  (MPEGPS, mpegps);
	REGISTER_MUXDEMUX (MPEGTS, mpegts);
	REGISTER_DEMUXER  (MPEGTSRAW, mpegtsraw);
	REGISTER_DEMUXER  (MPEGVIDEO, mpegvideo);
	REGISTER_MUXER    (MPJPEG, mpjpeg);
	REGISTER_DEMUXER  (MSNWC_TCP, msnwc_tcp);
	REGISTER_DEMUXER  (MTV, mtv);
	REGISTER_DEMUXER  (MVI, mvi);
	REGISTER_MUXDEMUX (MXF, mxf);
	REGISTER_MUXER    (MXF_D10, mxf_d10);
	REGISTER_DEMUXER  (NC, nc);
	REGISTER_DEMUXER  (NSV, nsv);
	REGISTER_MUXER    (NULL, null);
	REGISTER_MUXDEMUX (NUT, nut);
	REGISTER_DEMUXER  (NUV, nuv);
	REGISTER_MUXDEMUX (OGG, ogg);
	REGISTER_DEMUXER  (OMA, oma);
	REGISTER_MUXDEMUX (PCM_ALAW,  pcm_alaw);
	REGISTER_MUXDEMUX (PCM_MULAW, pcm_mulaw);
	REGISTER_MUXDEMUX (PCM_F64BE, pcm_f64be);
	REGISTER_MUXDEMUX (PCM_F64LE, pcm_f64le);
	REGISTER_MUXDEMUX (PCM_F32BE, pcm_f32be);
	REGISTER_MUXDEMUX (PCM_F32LE, pcm_f32le);
	REGISTER_MUXDEMUX (PCM_S32BE, pcm_s32be);
	REGISTER_MUXDEMUX (PCM_S32LE, pcm_s32le);
	REGISTER_MUXDEMUX (PCM_S24BE, pcm_s24be);
	REGISTER_MUXDEMUX (PCM_S24LE, pcm_s24le);
	REGISTER_MUXDEMUX (PCM_S16BE, pcm_s16be);
	REGISTER_MUXDEMUX (PCM_S16LE, pcm_s16le);
	REGISTER_MUXDEMUX (PCM_S8,    pcm_s8);
	REGISTER_MUXDEMUX (PCM_U32BE, pcm_u32be);
	REGISTER_MUXDEMUX (PCM_U32LE, pcm_u32le);
	REGISTER_MUXDEMUX (PCM_U24BE, pcm_u24be);
	REGISTER_MUXDEMUX (PCM_U24LE, pcm_u24le);
	REGISTER_MUXDEMUX (PCM_U16BE, pcm_u16be);
	REGISTER_MUXDEMUX (PCM_U16LE, pcm_u16le);
	REGISTER_MUXDEMUX (PCM_U8,    pcm_u8);
	REGISTER_MUXER    (PSP, psp);
	REGISTER_DEMUXER  (PVA, pva);
	REGISTER_DEMUXER  (QCP, qcp);
	REGISTER_DEMUXER  (R3D, r3d);
	REGISTER_MUXDEMUX (RAWVIDEO, rawvideo);
	REGISTER_DEMUXER  (RL2, rl2);
	REGISTER_MUXDEMUX (RM, rm);
	REGISTER_MUXDEMUX (ROQ, roq);
	REGISTER_DEMUXER  (RPL, rpl);
	REGISTER_MUXER    (RTP, rtp);
	REGISTER_MUXDEMUX (RTSP, rtsp);
	REGISTER_DEMUXER  (SDP, sdp);
#if CONFIG_SDP_DEMUXER
	av_register_rtp_dynamic_payload_handlers();
	av_register_rdt_dynamic_payload_handlers();
#endif
	REGISTER_DEMUXER  (SEGAFILM, segafilm);
	REGISTER_DEMUXER  (SHORTEN, shorten);
	REGISTER_DEMUXER  (SIFF, siff);
	REGISTER_DEMUXER  (SMACKER, smacker);
	REGISTER_DEMUXER  (SOL, sol);
	REGISTER_MUXDEMUX (SOX, sox);
	REGISTER_MUXER    (SPDIF, spdif);
	REGISTER_DEMUXER  (STR, str);
	REGISTER_MUXDEMUX (SWF, swf);
	REGISTER_MUXER    (TG2, tg2);
	REGISTER_MUXER    (TGP, tgp);
	REGISTER_DEMUXER  (THP, thp);
	REGISTER_DEMUXER  (TIERTEXSEQ, tiertexseq);
	REGISTER_DEMUXER  (TMV, tmv);
	REGISTER_MUXDEMUX (TRUEHD, truehd);
	REGISTER_DEMUXER  (TTA, tta);
	REGISTER_DEMUXER  (TXD, txd);
	REGISTER_DEMUXER  (VC1, vc1);
	REGISTER_MUXDEMUX (VC1T, vc1t);
	REGISTER_DEMUXER  (VMD, vmd);
	REGISTER_MUXDEMUX (VOC, voc);
	REGISTER_DEMUXER  (VQF, vqf);
	REGISTER_DEMUXER  (W64, w64);
	REGISTER_MUXDEMUX (WAV, wav);
	REGISTER_DEMUXER  (WC3, wc3);
	REGISTER_MUXER    (WEBM, webm);
	REGISTER_DEMUXER  (WSAUD, wsaud);
	REGISTER_DEMUXER  (WSVQA, wsvqa);
	REGISTER_DEMUXER  (WV, wv);
	REGISTER_DEMUXER  (XA, xa);
	REGISTER_DEMUXER  (YOP, yop);
	REGISTER_MUXDEMUX (YUV4MPEGPIPE, yuv4mpegpipe);

	/* external libraries */
	REGISTER_MUXDEMUX (LIBNUT, libnut);

	/* protocols */
	REGISTER_PROTOCOL (FILE, file);
	REGISTER_PROTOCOL (GOPHER, gopher);
	REGISTER_PROTOCOL (HTTP, http);
	REGISTER_PROTOCOL (PIPE, pipe);
	REGISTER_PROTOCOL (RTMP, rtmp);
#if CONFIG_LIBRTMP
	REGISTER_PROTOCOL (RTMP, rtmpt);
	REGISTER_PROTOCOL (RTMP, rtmpe);
	REGISTER_PROTOCOL (RTMP, rtmpte);
	REGISTER_PROTOCOL (RTMP, rtmps);
#endif
	REGISTER_PROTOCOL (RTP, rtp);
	REGISTER_PROTOCOL (TCP, tcp);
	REGISTER_PROTOCOL (UDP, udp);
	REGISTER_PROTOCOL (CONCAT, concat);
#else
    /* (de)muxers */
    
#if CONFIG_AAC_DEMUXER
 REGISTER_DEMUXER (AAC, aac);
#endif
    
#if CONFIG_AC3_MUXER
 REGISTER_MUXDEMUX (AC3, ac3);
#endif
    
#if CONFIG_ADTS_MUXER
 REGISTER_MUXER (ADTS, adts);
#endif
    
#if CONFIG_AEA_DEMUXER
 REGISTER_DEMUXER (AEA, aea);
#endif
    
#if CONFIG_AIFF_MUXER
 REGISTER_MUXDEMUX (AIFF, aiff);
#endif
    
#if CONFIG_AMR_MUXER
 REGISTER_MUXDEMUX (AMR, amr);
#endif
    
#if CONFIG_ANM_DEMUXER
 REGISTER_DEMUXER (ANM, anm);
#endif
    
#if CONFIG_APC_DEMUXER
 REGISTER_DEMUXER (APC, apc);
#endif
    
#if CONFIG_APE_DEMUXER
 REGISTER_DEMUXER (APE, ape);
#endif
    
#if CONFIG_ASF_MUXER
 REGISTER_MUXDEMUX (ASF, asf);
#endif
    
#if CONFIG_ASS_MUXER
 REGISTER_MUXDEMUX (ASS, ass);
#endif
    
#if CONFIG_ASF_STREAM_MUXER
 REGISTER_MUXER (ASF_STREAM, asf_stream);
#endif
    
#if CONFIG_AU_MUXER
 REGISTER_MUXDEMUX (AU, au);
#endif
    
#if CONFIG_AVI_MUXER
 REGISTER_MUXDEMUX (AVI, avi);
#endif
    
#if CONFIG_AVISYNTH_DEMUXER
 REGISTER_DEMUXER (AVISYNTH, avisynth);
#endif
    
#if CONFIG_AVM2_MUXER
 REGISTER_MUXER (AVM2, avm2);
#endif
    
#if CONFIG_AVS_DEMUXER
 REGISTER_DEMUXER (AVS, avs);
#endif
    
#if CONFIG_BETHSOFTVID_DEMUXER
 REGISTER_DEMUXER (BETHSOFTVID, bethsoftvid);
#endif
    
#if CONFIG_BFI_DEMUXER
 REGISTER_DEMUXER (BFI, bfi);
#endif
    
#if CONFIG_BINK_DEMUXER
 REGISTER_DEMUXER (BINK, bink);
#endif
    
#if CONFIG_C93_DEMUXER
 REGISTER_DEMUXER (C93, c93);
#endif
    
#if CONFIG_CAF_DEMUXER
 REGISTER_DEMUXER (CAF, caf);
#endif
    
#if CONFIG_CAVSVIDEO_DEMUXER
 REGISTER_DEMUXER (CAVSVIDEO, cavsvideo);
#endif
    
#if CONFIG_CDG_DEMUXER
 REGISTER_DEMUXER (CDG, cdg);
#endif
    
#if CONFIG_CRC_MUXER
 REGISTER_MUXER (CRC, crc);
#endif
    
#if CONFIG_DAUD_MUXER
 REGISTER_MUXDEMUX (DAUD, daud);
#endif
    
#if CONFIG_DIRAC_MUXER
 REGISTER_MUXDEMUX (DIRAC, dirac);
#endif
    
#if CONFIG_DNXHD_MUXER
 REGISTER_MUXDEMUX (DNXHD, dnxhd);
#endif
    
#if CONFIG_DSICIN_DEMUXER
 REGISTER_DEMUXER (DSICIN, dsicin);
#endif
    
#if CONFIG_DTS_MUXER
 REGISTER_MUXDEMUX (DTS, dts);
#endif
    
#if CONFIG_DV_MUXER
 REGISTER_MUXDEMUX (DV, dv);
#endif
    
#if CONFIG_DXA_DEMUXER
 REGISTER_DEMUXER (DXA, dxa);
#endif
    
#if CONFIG_EA_DEMUXER
 REGISTER_DEMUXER (EA, ea);
#endif
    
#if CONFIG_EA_CDATA_DEMUXER
 REGISTER_DEMUXER (EA_CDATA, ea_cdata);
#endif
    
#if CONFIG_EAC3_MUXER
 REGISTER_MUXDEMUX (EAC3, eac3);
#endif
    
#if CONFIG_FFM_MUXER
 REGISTER_MUXDEMUX (FFM, ffm);
#endif
    
#if CONFIG_FILMSTRIP_MUXER
 REGISTER_MUXDEMUX (FILMSTRIP, filmstrip);
#endif
    
#if CONFIG_FLAC_MUXER
 REGISTER_MUXDEMUX (FLAC, flac);
#endif
    
#if CONFIG_FLIC_DEMUXER
 REGISTER_DEMUXER (FLIC, flic);
#endif
    
#if CONFIG_FLV_MUXER
 REGISTER_MUXDEMUX (FLV, flv);
#endif
    
#if CONFIG_FOURXM_DEMUXER
 REGISTER_DEMUXER (FOURXM, fourxm);
#endif
    
#if CONFIG_FRAMECRC_MUXER
 REGISTER_MUXER (FRAMECRC, framecrc);
#endif
    
#if CONFIG_GIF_MUXER
 REGISTER_MUXER (GIF, gif);
#endif
    
#if CONFIG_GSM_DEMUXER
 REGISTER_DEMUXER (GSM, gsm);
#endif
    
#if CONFIG_GXF_MUXER
 REGISTER_MUXDEMUX (GXF, gxf);
#endif
    
#if CONFIG_H261_MUXER
 REGISTER_MUXDEMUX (H261, h261);
#endif
    
#if CONFIG_H263_MUXER
 REGISTER_MUXDEMUX (H263, h263);
#endif
    
#if CONFIG_H264_MUXER
 REGISTER_MUXDEMUX (H264, h264);
#endif
    
#if CONFIG_IDCIN_DEMUXER
 REGISTER_DEMUXER (IDCIN, idcin);
#endif
    
#if CONFIG_IFF_DEMUXER
 REGISTER_DEMUXER (IFF, iff);
#endif
    
#if CONFIG_IMAGE2_MUXER
 REGISTER_MUXDEMUX (IMAGE2, image2);
#endif
    
#if CONFIG_IMAGE2PIPE_MUXER
 REGISTER_MUXDEMUX (IMAGE2PIPE, image2pipe);
#endif
    
#if CONFIG_INGENIENT_DEMUXER
 REGISTER_DEMUXER (INGENIENT, ingenient);
#endif
    
#if CONFIG_IPMOVIE_DEMUXER
 REGISTER_DEMUXER (IPMOVIE, ipmovie);
#endif
    
#if CONFIG_IPOD_MUXER
 REGISTER_MUXER (IPOD, ipod);
#endif
    
#if CONFIG_ISS_DEMUXER
 REGISTER_DEMUXER (ISS, iss);
#endif
    
#if CONFIG_IV8_DEMUXER
 REGISTER_DEMUXER (IV8, iv8);
#endif
    
#if CONFIG_LMLM4_DEMUXER
 REGISTER_DEMUXER (LMLM4, lmlm4);
#endif
    
#if CONFIG_M4V_MUXER
 REGISTER_MUXDEMUX (M4V, m4v);
#endif
    
#if CONFIG_MATROSKA_MUXER
 REGISTER_MUXDEMUX (MATROSKA, matroska);
#endif
    
#if CONFIG_MATROSKA_AUDIO_MUXER
 REGISTER_MUXER (MATROSKA_AUDIO, matroska_audio);
#endif
    
#if CONFIG_MJPEG_MUXER
 REGISTER_MUXDEMUX (MJPEG, mjpeg);
#endif
    
#if CONFIG_MLP_MUXER
 REGISTER_MUXDEMUX (MLP, mlp);
#endif
    
#if CONFIG_MM_DEMUXER
 REGISTER_DEMUXER (MM, mm);
#endif
    
#if CONFIG_MMF_MUXER
 REGISTER_MUXDEMUX (MMF, mmf);
#endif
    
#if CONFIG_MOV_MUXER
 REGISTER_MUXDEMUX (MOV, mov);
#endif
    
#if CONFIG_MP2_MUXER
 REGISTER_MUXER (MP2, mp2);
#endif
    
#if CONFIG_MP3_MUXER
 REGISTER_MUXDEMUX (MP3, mp3);
#endif
    
#if CONFIG_MP4_MUXER
 REGISTER_MUXER (MP4, mp4);
#endif
    
#if CONFIG_MPC_DEMUXER
 REGISTER_DEMUXER (MPC, mpc);
#endif
    
#if CONFIG_MPC8_DEMUXER
 REGISTER_DEMUXER (MPC8, mpc8);
#endif
    
#if CONFIG_MPEG1SYSTEM_MUXER
 REGISTER_MUXER (MPEG1SYSTEM, mpeg1system);
#endif
    
#if CONFIG_MPEG1VCD_MUXER
 REGISTER_MUXER (MPEG1VCD, mpeg1vcd);
#endif
    
#if CONFIG_MPEG1VIDEO_MUXER
 REGISTER_MUXER (MPEG1VIDEO, mpeg1video);
#endif
    
#if CONFIG_MPEG2DVD_MUXER
 REGISTER_MUXER (MPEG2DVD, mpeg2dvd);
#endif
    
#if CONFIG_MPEG2SVCD_MUXER
 REGISTER_MUXER (MPEG2SVCD, mpeg2svcd);
#endif
    
#if CONFIG_MPEG2VIDEO_MUXER
 REGISTER_MUXER (MPEG2VIDEO, mpeg2video);
#endif
    
#if CONFIG_MPEG2VOB_MUXER
 REGISTER_MUXER (MPEG2VOB, mpeg2vob);
#endif
    
#if CONFIG_MPEGPS_DEMUXER
 REGISTER_DEMUXER (MPEGPS, mpegps);
#endif
    
#if CONFIG_MPEGTS_MUXER
 REGISTER_MUXDEMUX (MPEGTS, mpegts);
#endif
    
#if CONFIG_MPEGTSRAW_DEMUXER
 REGISTER_DEMUXER (MPEGTSRAW, mpegtsraw);
#endif
    
#if CONFIG_MPEGVIDEO_DEMUXER
 REGISTER_DEMUXER (MPEGVIDEO, mpegvideo);
#endif
    
#if CONFIG_MPJPEG_MUXER
 REGISTER_MUXER (MPJPEG, mpjpeg);
#endif
    
#if CONFIG_MSNWC_TCP_DEMUXER
 REGISTER_DEMUXER (MSNWC_TCP, msnwc_tcp);
#endif
    
#if CONFIG_MTV_DEMUXER
 REGISTER_DEMUXER (MTV, mtv);
#endif
    
#if CONFIG_MVI_DEMUXER
 REGISTER_DEMUXER (MVI, mvi);
#endif
    
#if CONFIG_MXF_MUXER
 REGISTER_MUXDEMUX (MXF, mxf);
#endif
    
#if CONFIG_MXF_D10_MUXER
 REGISTER_MUXER (MXF_D10, mxf_d10);
#endif
    
#if CONFIG_NC_DEMUXER
 REGISTER_DEMUXER (NC, nc);
#endif
    
#if CONFIG_NSV_DEMUXER
 REGISTER_DEMUXER (NSV, nsv);
#endif
    
#if CONFIG_NULL_MUXER
 REGISTER_MUXER (NULL, null);
#endif
    
#if CONFIG_NUT_MUXER
 REGISTER_MUXDEMUX (NUT, nut);
#endif
    
#if CONFIG_NUV_DEMUXER
 REGISTER_DEMUXER (NUV, nuv);
#endif
    
#if CONFIG_OGG_MUXER
 REGISTER_MUXDEMUX (OGG, ogg);
#endif
    
#if CONFIG_OMA_DEMUXER
 REGISTER_DEMUXER (OMA, oma);
#endif
    
#if CONFIG_PCM_ALAW_MUXER
 REGISTER_MUXDEMUX (PCM_ALAW, pcm_alaw);
#endif
    
#if CONFIG_PCM_MULAW_MUXER
 REGISTER_MUXDEMUX (PCM_MULAW, pcm_mulaw);
#endif
    
#if CONFIG_PCM_F64BE_MUXER
 REGISTER_MUXDEMUX (PCM_F64BE, pcm_f64be);
#endif
    
#if CONFIG_PCM_F64LE_MUXER
 REGISTER_MUXDEMUX (PCM_F64LE, pcm_f64le);
#endif
    
#if CONFIG_PCM_F32BE_MUXER
 REGISTER_MUXDEMUX (PCM_F32BE, pcm_f32be);
#endif
    
#if CONFIG_PCM_F32LE_MUXER
 REGISTER_MUXDEMUX (PCM_F32LE, pcm_f32le);
#endif
    
#if CONFIG_PCM_S32BE_MUXER
 REGISTER_MUXDEMUX (PCM_S32BE, pcm_s32be);
#endif
    
#if CONFIG_PCM_S32LE_MUXER
 REGISTER_MUXDEMUX (PCM_S32LE, pcm_s32le);
#endif
    
#if CONFIG_PCM_S24BE_MUXER
 REGISTER_MUXDEMUX (PCM_S24BE, pcm_s24be);
#endif
    
#if CONFIG_PCM_S24LE_MUXER
 REGISTER_MUXDEMUX (PCM_S24LE, pcm_s24le);
#endif
    
#if CONFIG_PCM_S16BE_MUXER
 REGISTER_MUXDEMUX (PCM_S16BE, pcm_s16be);
#endif
    
#if CONFIG_PCM_S16LE_MUXER
 REGISTER_MUXDEMUX (PCM_S16LE, pcm_s16le);
#endif
    
#if CONFIG_PCM_S8_MUXER
 REGISTER_MUXDEMUX (PCM_S8, pcm_s8);
#endif
    
#if CONFIG_PCM_U32BE_MUXER
 REGISTER_MUXDEMUX (PCM_U32BE, pcm_u32be);
#endif
    
#if CONFIG_PCM_U32LE_MUXER
 REGISTER_MUXDEMUX (PCM_U32LE, pcm_u32le);
#endif
    
#if CONFIG_PCM_U24BE_MUXER
 REGISTER_MUXDEMUX (PCM_U24BE, pcm_u24be);
#endif
    
#if CONFIG_PCM_U24LE_MUXER
 REGISTER_MUXDEMUX (PCM_U24LE, pcm_u24le);
#endif
    
#if CONFIG_PCM_U16BE_MUXER
 REGISTER_MUXDEMUX (PCM_U16BE, pcm_u16be);
#endif
    
#if CONFIG_PCM_U16LE_MUXER
 REGISTER_MUXDEMUX (PCM_U16LE, pcm_u16le);
#endif
    
#if CONFIG_PCM_U8_MUXER
 REGISTER_MUXDEMUX (PCM_U8, pcm_u8);
#endif
    
#if CONFIG_PSP_MUXER
 REGISTER_MUXER (PSP, psp);
#endif
    
#if CONFIG_PVA_DEMUXER
 REGISTER_DEMUXER (PVA, pva);
#endif
    
#if CONFIG_QCP_DEMUXER
 REGISTER_DEMUXER (QCP, qcp);
#endif
    
#if CONFIG_R3D_DEMUXER
 REGISTER_DEMUXER (R3D, r3d);
#endif
    
#if CONFIG_RAWVIDEO_MUXER
 REGISTER_MUXDEMUX (RAWVIDEO, rawvideo);
#endif
    
#if CONFIG_RL2_DEMUXER
 REGISTER_DEMUXER (RL2, rl2);
#endif
    
#if CONFIG_RM_MUXER
 REGISTER_MUXDEMUX (RM, rm);
#endif
    
#if CONFIG_ROQ_MUXER
 REGISTER_MUXDEMUX (ROQ, roq);
#endif
    
#if CONFIG_RPL_DEMUXER
 REGISTER_DEMUXER (RPL, rpl);
#endif
    
#if CONFIG_RTP_MUXER
 REGISTER_MUXER (RTP, rtp);
#endif
    
#if CONFIG_RTSP_MUXER
 REGISTER_MUXDEMUX (RTSP, rtsp);
#endif
    
#if CONFIG_SDP_DEMUXER
 REGISTER_DEMUXER (SDP, sdp);
#endif
#if CONFIG_SDP_DEMUXER
    av_register_rtp_dynamic_payload_handlers();
    av_register_rdt_dynamic_payload_handlers();
#endif
    
#if CONFIG_SEGAFILM_DEMUXER
 REGISTER_DEMUXER (SEGAFILM, segafilm);
#endif
    
#if CONFIG_SHORTEN_DEMUXER
 REGISTER_DEMUXER (SHORTEN, shorten);
#endif
    
#if CONFIG_SIFF_DEMUXER
 REGISTER_DEMUXER (SIFF, siff);
#endif
    
#if CONFIG_SMACKER_DEMUXER
 REGISTER_DEMUXER (SMACKER, smacker);
#endif
    
#if CONFIG_SOL_DEMUXER
 REGISTER_DEMUXER (SOL, sol);
#endif
    
#if CONFIG_SOX_MUXER
 REGISTER_MUXDEMUX (SOX, sox);
#endif
    
#if CONFIG_SPDIF_MUXER
 REGISTER_MUXER (SPDIF, spdif);
#endif
    
#if CONFIG_STR_DEMUXER
 REGISTER_DEMUXER (STR, str);
#endif
    
#if CONFIG_SWF_MUXER
 REGISTER_MUXDEMUX (SWF, swf);
#endif
    
#if CONFIG_TG2_MUXER
 REGISTER_MUXER (TG2, tg2);
#endif
    
#if CONFIG_TGP_MUXER
 REGISTER_MUXER (TGP, tgp);
#endif
    
#if CONFIG_THP_DEMUXER
 REGISTER_DEMUXER (THP, thp);
#endif
    
#if CONFIG_TIERTEXSEQ_DEMUXER
 REGISTER_DEMUXER (TIERTEXSEQ, tiertexseq);
#endif
    
#if CONFIG_TMV_DEMUXER
 REGISTER_DEMUXER (TMV, tmv);
#endif
    
#if CONFIG_TRUEHD_MUXER
 REGISTER_MUXDEMUX (TRUEHD, truehd);
#endif
    
#if CONFIG_TTA_DEMUXER
 REGISTER_DEMUXER (TTA, tta);
#endif
    
#if CONFIG_TXD_DEMUXER
 REGISTER_DEMUXER (TXD, txd);
#endif
    
#if CONFIG_VC1_DEMUXER
 REGISTER_DEMUXER (VC1, vc1);
#endif
    
#if CONFIG_VC1T_MUXER
 REGISTER_MUXDEMUX (VC1T, vc1t);
#endif
    
#if CONFIG_VMD_DEMUXER
 REGISTER_DEMUXER (VMD, vmd);
#endif
    
#if CONFIG_VOC_MUXER
 REGISTER_MUXDEMUX (VOC, voc);
#endif
    
#if CONFIG_VQF_DEMUXER
 REGISTER_DEMUXER (VQF, vqf);
#endif
    
#if CONFIG_W64_DEMUXER
 REGISTER_DEMUXER (W64, w64);
#endif
    
#if CONFIG_WAV_MUXER
 REGISTER_MUXDEMUX (WAV, wav);
#endif
    
#if CONFIG_WC3_DEMUXER
 REGISTER_DEMUXER (WC3, wc3);
#endif
    
#if CONFIG_WEBM_MUXER
 REGISTER_MUXER (WEBM, webm);
#endif
    
#if CONFIG_WSAUD_DEMUXER
 REGISTER_DEMUXER (WSAUD, wsaud);
#endif
    
#if CONFIG_WSVQA_DEMUXER
 REGISTER_DEMUXER (WSVQA, wsvqa);
#endif
    
#if CONFIG_WV_DEMUXER
 REGISTER_DEMUXER (WV, wv);
#endif
    
#if CONFIG_XA_DEMUXER
 REGISTER_DEMUXER (XA, xa);
#endif
    
#if CONFIG_YOP_DEMUXER
 REGISTER_DEMUXER (YOP, yop);
#endif
    
#if CONFIG_YUV4MPEGPIPE_MUXER
 REGISTER_MUXDEMUX (YUV4MPEGPIPE, yuv4mpegpipe);
#endif

    /* external libraries */
    
#if CONFIG_LIBNUT_MUXER
 REGISTER_MUXDEMUX (LIBNUT, libnut);
#endif

    /* protocols */
    
#if CONFIG_FILE_PROTOCOL
 REGISTER_PROTOCOL (FILE, file);
#endif
    
#if CONFIG_GOPHER_PROTOCOL
 REGISTER_PROTOCOL (GOPHER, gopher);
#endif
    
#if CONFIG_HTTP_PROTOCOL
 REGISTER_PROTOCOL (HTTP, http);
#endif
    
#if CONFIG_PIPE_PROTOCOL
 REGISTER_PROTOCOL (PIPE, pipe);
#endif
    
#if CONFIG_RTMP_PROTOCOL
 REGISTER_PROTOCOL (RTMP, rtmp);
#endif
#if CONFIG_LIBRTMP
    
#if CONFIG_RTMP_PROTOCOL
 REGISTER_PROTOCOL (RTMP, rtmpt);
#endif
    
#if CONFIG_RTMP_PROTOCOL
 REGISTER_PROTOCOL (RTMP, rtmpe);
#endif
    
#if CONFIG_RTMP_PROTOCOL
 REGISTER_PROTOCOL (RTMP, rtmpte);
#endif
    
#if CONFIG_RTMP_PROTOCOL
 REGISTER_PROTOCOL (RTMP, rtmps);
#endif
#endif
    
#if CONFIG_RTP_PROTOCOL
 REGISTER_PROTOCOL (RTP, rtp);
#endif
    
#if CONFIG_TCP_PROTOCOL
 REGISTER_PROTOCOL (TCP, tcp);
#endif
    
#if CONFIG_UDP_PROTOCOL
 REGISTER_PROTOCOL (UDP, udp);
#endif
    
#if CONFIG_CONCAT_PROTOCOL
 REGISTER_PROTOCOL (CONCAT, concat);
#endif

#endif
}
